home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / vol_200 / 201_01 / fdires.c < prev    next >
Text File  |  1980-01-01  |  14KB  |  534 lines
  1.  
  2. /****************************************************************************/
  3. /*                                        */
  4. /*     FDIRES.C   Version 1.3  3/6/86               Brian Irvine        */
  5. /*                                        */
  6. /*      Released to the Public Domain for use without profit            */
  7. /*                                        */
  8. /****************************************************************************/
  9. /*                                        */
  10. /* fdires.c - Program to demonstrate use of stayres.c in creating a        */
  11. /*          terminate-and-stay-resident program in DeSmet C.            */
  12. /*                                        */
  13. /*          This program demonstrates the techniques used to create a     */
  14. /*          program which will terminate but remain resident as part        */
  15. /*          of DOS.  The program is a sorted directory displayer which    */
  16. /*          will show a sorted and formatted listing of files on the        */
  17. /*          current directory.  It is supplied mainly to demonstrate        */
  18. /*          the techniques involved in creating TSR programs.         */
  19. /*                                        */
  20. /*          The program is activated with the Alt F-10 key.  This will    */
  21. /*          display a sorted listing of the files on the current        */
  22. /*          directory.  The display will remain until a key is pressed.   */
  23. /*          If the Ctrl F-10 key is pressed, the program will be        */
  24. /*          removed from memory and you will be returned to DOS.        */
  25. /*          Do NOT exit this way if you are running FDIRES from within    */
  26. /*          an application program.  You will bomb the computer when        */
  27. /*          you try to return to your application.  Pressing any key        */
  28. /*          other than Ctrl F-10 will return you to your application.     */
  29. /*                                        */
  30. /*          The program must be linked with the other module in this        */
  31. /*          library using the -s option of bind with a stack allowance    */
  32. /*          of 0x1000 (4096 decimal).  This should be more than        */
  33. /*          adequate for 99% of all applications.                */
  34. /*                                        */
  35. /*          This code is based in part on a set of routines written by    */
  36. /*          Lane Ferris et al which are available on the Borland SIG on   */
  37. /*          Compuserve.                            */
  38. /*                                        */
  39. /*           Brian Irvine                            */
  40. /*           3379 St Marys Place                        */
  41. /*           Santa Clara, CA 95051                        */
  42. /*           [71016,544]                            */
  43. /*                                        */
  44. /****************************************************************************/
  45. /*                                        */
  46. /* Revisions:                                    */
  47. /*     version 1.0 - 10/85                            */
  48. /*     Initial release                                */
  49. /*                                        */
  50. /*     version 1.20 - 3/3/86                            */
  51. /*     Added code to remove program from memory.                */
  52. /*     New version of resident code                        */
  53. /*                                        */
  54. /*     version 1.30 - 3/6/86                            */
  55. /*     Added code to check for program already in memory            */
  56. /*                                        */
  57. /****************************************************************************/
  58.  
  59. #include   <stdio.h>
  60.  
  61. #define    KILL_CHAR       255
  62. #define    MAX_DIRS       1000
  63.  
  64. #define    KB_INT       0x16
  65. #define    DOS_INT       0x21
  66. #define    GET_DRV       0x19
  67.  
  68. #define    FILE_NOT_FOUND  2           /* DOS function error codes */
  69. #define    INVALID_DRIVE   15
  70. #define    NO_MORE_FILES   18
  71.  
  72. struct {
  73.     char   reserved[21];           /* disk transfer area */
  74.     char   attribute;
  75.     int    time;
  76.     int    date;
  77.     long   file_size;
  78.     char   name[13];
  79.     } dta;
  80.  
  81. struct dir_entry{               /* directory entry */
  82.     char    e_attribute;
  83.     int    e_time;
  84.     int    e_date;
  85.     long    e_file_size;
  86.     char    e_name[13];
  87.     } entry[MAX_DIRS];           /* enough room for 1000 entries */
  88.  
  89. long   free_space;
  90. long   total_space;
  91. int    entries = 0;
  92. int    _rax, _rbx, _rcx, _rdx,       /* variables to hold register values */
  93.           _rsi, _rdi, _rds, _res;
  94. int    row, column;           /* cursor position - must be global */
  95.  
  96. extern char    _carryf;
  97.  
  98. char   label [12];
  99. char   pathname [65];
  100. char   buffer [65];
  101. static char   save_screen[4000];      /* save the screen here */
  102. long   get_free ();
  103.  
  104. extern unsigned old_kbint_off;
  105. extern unsigned old_kbint_seg;
  106. extern int     check_dupe();   /* the code to prevent loading program twice */
  107. extern void    stayres();      /* the code to terminate and stay resident */
  108.  
  109.  
  110. /*----- Main ---------------------------------------------------------------*/
  111. /*                                        */
  112. /*     In this application all we have to do is call the tsr code.  Other   */
  113. /*     initialization can be performed here before fencing ourselves off.   */
  114. /*                                        */
  115. /*--------------------------------------------------------------------------*/
  116.  
  117. main ()
  118. {
  119.  
  120.    /* first thing is to check to see if program is already loaded */
  121.  
  122.    if ( check_dupe () )
  123.        puts("\nFDIRES is already in memory.\n\n");
  124.    else
  125.        stayres ();
  126.  
  127. }
  128.  
  129. /*----- Main program entry point -------------------------------------------*/
  130.  
  131. fdir ()
  132. {
  133.  
  134.    char    ch;
  135.    int       n, stat, curr_drv;
  136.    int       mode;
  137.    unsigned    screen_seg;
  138.  
  139.    /* get the video mode */
  140.  
  141.    mode = get_mode ();
  142.  
  143.    /* save the user's screen and cursor position */
  144.  
  145.    find_cursor ();
  146.    if ( mode == 7 )
  147.        screen_seg = 0xB000;
  148.    else
  149.        screen_seg = 0xB800;
  150.    _lmove ( 4000, 0, screen_seg, save_screen, _showds() );
  151.    scr_clr ();
  152.    scr_rowcol (0,0);
  153.  
  154.    entries = 0;
  155.    _setmem (buffer, 65, '\0' );        /* initialize buffers explicitly each */
  156.    _setmem (pathname, 65, '\0' );      /* time through because it changes */
  157.    if ( get_path () == ERR )
  158.        {
  159.        puts ("Invalid drive specifier.\n");
  160.        exit(1);
  161.        }
  162.  
  163. /*     Now construct the path name using current drive                */
  164.  
  165.    curr_drv = get_curr_drv ();
  166.    buffer[0] = curr_drv + 'A';
  167.    buffer[1] = ':';
  168.    if ( strlen ( pathname ) == 0 )
  169.        buffer[2] = '\0';
  170.    else
  171.        {
  172.        buffer[2] = '\\';
  173.        buffer[3] = '\0';
  174.        }
  175.  
  176.    strcat ( buffer, pathname );
  177.    strcpy ( pathname, buffer );
  178.    n = ( 80 - strlen ( pathname ) - 14 ) / 2;
  179.    strncpy ( buffer, "                                ", n);
  180.    strcat ( buffer, "Directory of " );
  181.    strcat ( buffer, pathname );
  182.    printf ( "%s\n\n", buffer );
  183.    set_dta ();
  184.  
  185. /*     Get the first matching directory entry                    */
  186.  
  187.    if ( get_first () )
  188.        {
  189.        puts ("File not found.\n");
  190.        exit (1);
  191.        }
  192.  
  193. /*     Now collect all the other matching names                 */
  194.  
  195.    while ( ( stat = get_next () ) != NO_MORE_FILES )
  196.        ;
  197.    free_space = get_free ();
  198.    sort_files ();
  199.    print_files ();
  200.  
  201.    /* now put everything back where it was */
  202.  
  203.    puts ("\nPress any key to continue...");
  204.    while ( ( ch = scr_csts() ) == 0 )
  205.        ;
  206.    if ( ch == KILL_CHAR )      /* if we want to get rid of the program then */
  207.        {
  208.        purge();            /* reset the keyboard vector and free memory */
  209.        exit(0);
  210.        }
  211.    else
  212.        {
  213.        _lmove ( 4000, save_screen, _showds(), 0, screen_seg );
  214.        scr_rowcol ( row, column );
  215.        }
  216.  
  217.  
  218. }
  219.  
  220.  
  221.  
  222. /*----- Kill the resident program ------------------------------------------*/
  223.  
  224. void   purge ()
  225. {
  226.  
  227. unsigned   psp, envptr;
  228.  
  229.    psp = _showcs() - 0x10;
  230.    _lmove(2, 0x2C, psp, &envptr, _showds());
  231.  
  232.    puts ("\n\nFDIRES terminated. Urghhh...\n\n");
  233.  
  234. /* reset the keyboard interrupt service vector */
  235.  
  236.    _rds = old_kbint_seg;
  237.    _rdx = old_kbint_off;
  238.    _rax = 0x2500 + KB_INT;
  239.    _doint ( DOS_INT );
  240.  
  241. /* free up the program memory */
  242.  
  243.    _rax = 0x4900;
  244.    _res = psp;               /* point to beginning of PSP for EXE file */
  245.    _doint ( DOS_INT );
  246.  
  247. /* free up the environment area */
  248.  
  249.    _rax = 0x4900;
  250.    _res = envptr;           /* point to environment area */
  251.    _doint ( DOS_INT );
  252.  
  253. }
  254.  
  255.  
  256. /*----- Get the current drive number ---------------------------------------*/
  257.  
  258. int    get_curr_drv ()
  259. {
  260.  
  261.    return ( _os ( GET_DRV, 0 ) );
  262.  
  263. }
  264.  
  265.  
  266.  
  267. /*----- Get path name of current directory ---------------------------------*/
  268.  
  269. int    get_path ()
  270. {
  271.  
  272.    _rax = 0x4700;
  273.    _rdx = 0;
  274.    _rsi = &pathname[0];
  275.    _rds = _showds();
  276.    _doint ( DOS_INT );
  277.    if ( _carryf )
  278.        return ERR;
  279.  
  280. }
  281.  
  282.  
  283.  
  284. /*----- Give the DTA address t